// const s1 = Symbol("foo");
// const s2 = Symbol("foo");

// // console.log(s1 === s2);

// const kj = Reflect.ownKeys({
//   a: 1,
//   b: 2,
//   c: 3,
//   [s1]: 4,
//   [s2]: 5,
//   [Symbol("foo")]: 6,
//   [Symbol("foo")]: 7,
//   [Symbol.for("foo")]: 8,
//   [Symbol.for("foo")]: 9,
//   [Symbol.iterator]: 10,
//   [Symbol.iterator]: 11,
// });

// const g = Reflect.set(kj, "a", 100);
// const g2 = Reflect.get(kj, "a");
// console.log(g2);

// var obj = {
//   x: 1,
//   y: 2,
//   z: 4,
// };

// var objx = {
//   foo: 1,
//   bar: 2,
//   baz: 4,
//   [obj]: 56,
// };
// console.log(objx[obj]);

// for (const element in objx) {
//   console.log(element);
// }

// class text {}
// let t = new text();
// // console.log(t);

// let wk = new WeakMap();
// wk.set(t, "123");

// let mp = new Map();
// mp.set(t, "123");

// mp = null;
// wk = null;
// // console.log(wk);

// console.log(mp);


// const rc = [1,2,3,4,5,6].reduce((pre, cur, index, array) => {
//   console.log(pre, cur);
//   return pre + cur;
  
// },10)

// console.log(rc);


// const target = {
//   name: 'Alice',
//   greet() {
//     return `Hello, ${this.name}!`;
//   },
// };

// const proxy = new Proxy(target, {
//   get(target, property, receiver) {
//     // 直接返回 target[property]，忽略 receiver
//     return target[property];
//   },
// });

// const child = {
//   name: 'Bob',
//   __proto__: proxy,
// };

// console.log(child.greet()); // 输出: Hello, Alice!


// const target1 = {
//   name: 'Alice',
// };

// Object.defineProperty(target1, 'age', {
//   value: 25,
//   writable: false, // age 属性不可写
// });

// const proxy1 = new Proxy(target1, {
//   set(target, property, value) {
//     // 直接设置 target[property]，忽略属性描述符
//     target[property] = value;
//     return true;
//   },
// });

// proxy1.age = 30; // 静默失败，没有报错
// console.log(proxy1.age); // 输出: 25


// const target = [];

// const proxy = new Proxy(target, {
//   set(target, property, value) {
//     // 直接设置 target[property]，忽略数组操作的默认行为
//     target[property] = value;
//     return true;
//   },
// });

// proxy.push('Item 1'); // 输出: 1
// console.log(proxy); // 输出: ['Item 1']




// 如果不使用Reflect 会存在一下问题

//1、缺少默认行为
const target = {
  name: 'Alice',
  age: 25
};

Object.defineProperty(target, 'aget', {
  value: 25,
  writable: false, // age 属性不可写
})

const handler = {
  get(target, property, receiver) {
    // 不使用 Reflect
    // return target[property];
    return Reflect.get(target, property, receiver);
  },
  set(target, property, value, receiver) {
    // 不使用 Reflect
    // target[property] = value;
    // return true;
    return Reflect.set(target, property, value, receiver);
  }
};

const proxy = new Proxy(target, handler);

// 访问属性
console.log(proxy.name); // 输出: Alice

// 设置属性
proxy.age = 30;
console.log(proxy.age); // 输出: 30

//问题分析，这个时候 age是设置过不能被设置的，但是没有报错，所以存在问题



const target = {};
Object.defineProperty(target, 'readonlyProp', {
    value: 10,
    writable: false
});

const handlerWithoutReflect = {
    set(target, property, value) {
        target[property] = value; // 不使用 Reflect
        return true;
    }
};

const proxyWithoutReflect = new Proxy(target, handlerWithoutReflect);
// proxyWithoutReflect.readonlyProp = 30; 
// console.log(proxyWithoutReflect.readonlyProp); // 输出 10，虽然赋值但未报错

const handlerWithReflect = {
    set(target, property, value) {
        return Reflect.set(target, property, value);
    }
};

const proxyWithReflect = new Proxy(target, handlerWithReflect);
try {
    proxyWithReflect.readonlyProp = 20; 
} catch (error) {
    console.error('使用 Reflect 时捕获错误:', error); 
}


const obj = {
  name:'阳了',
  get foo(){
      return this.name;
  }
}
console.log(Reflect.get(obj, 'foo', obj));



const objy =  {a: 12}
Object.defineProperty(objy, 'c', {
  value: 10,
  enumerable: false
})

// console.log(Reflect.ownKeys(objy)); // [ 'a', 'c' ]
console.log(Object.keys(objy)); // [ 'a' ]












